/**
 * 整合逻辑：URL代理转换 → 批量下载TXT → 解析Base64（截取前235位）→ 返回图片链接
 * @param {Array<string>} urls - 原始URL数组（支持TXT/非TXT混合）
 * @param {string} mimeType - 图片格式（默认webp，可改png/jpeg）
 * @param {string} ossDomain - 目标OSS域名（需与代理配置匹配）
 * @param {string} proxyPrefix - 代理前缀（需与vite.config.js proxy一致）
 * @returns {Promise<{
 *   list: Array<{url:string, success:boolean, data:string}>,
 *   start: number,
 *   end: number,
 *   duration: number
 * }>}
 * - 成功（TXT）：data为完整Base64（data:image/...）
 * - 成功（非TXT）：data为原始URL
 * - 失败：data为原始URL
 */
export function ossImageToBase64(
  urls = [],
  mimeType = "webp",
  ossDomain = "https://manhuas.oss-cn-chengdu.aliyuncs.com",
  proxyPrefix = "/oss-img"
) {
  // 1. 基础入参校验：确保urls是数组
  if (!Array.isArray(urls) || urls.length === 0) {
    return Promise.resolve({
      list: [],
      start: 0,
      end: 0,
      duration: 0,
    });
  }

  const start = Date.now();

  // -------------------------- 核心子逻辑1：判断是否为TXT文件 --------------------------
  const isTxtUrl = (url) => {
    if (typeof url !== "string" || url.trim() === "") return false;
    const decodedUrl = decodeURIComponent(url.trim());
    const lastDotIndex = decodedUrl.lastIndexOf(".");
    // 无后缀/后缀仅为.（如"xxx."）→ 非TXT
    if (lastDotIndex === -1 || lastDotIndex === decodedUrl.length - 1)
      return false;
    // 提取后缀并转小写（兼容.TXT大写场景）
    const fileExt = decodedUrl.slice(lastDotIndex + 1).toLowerCase();
    return fileExt === "txt";
  };

  // -------------------------- 核心子逻辑2：URL代理转换（仅TXT文件） --------------------------
  const getProxyImageUrl = (originalUrl) => {
    // 防御：无效URL返回空
    if (typeof originalUrl !== "string" || originalUrl.trim() === "") {
      return originalUrl;
    }

    // 非TXT文件：不代理，直接返回原始URL
    if (!isTxtUrl(originalUrl)) {
      return originalUrl;
    }

    // TXT文件：仅目标OSS域名才转代理
    if (originalUrl.startsWith(ossDomain)) {
      const proxyUrl = originalUrl.replace(ossDomain, proxyPrefix);
      return proxyUrl;
    }

    // TXT文件但非目标OSS域名：不代理
    return originalUrl;
  };

  // -------------------------- 核心子逻辑3：单个URL处理（代理→下载→解析） --------------------------
  const handleSingleUrl = (originalUrl) => {
    return new Promise((resolve) => {
      // 步骤1：先做代理转换
      const proxyUrl = getProxyImageUrl(originalUrl);

      // 步骤2：非TXT文件 → 直接返回原始URL（无需解析）
      if (!isTxtUrl(originalUrl)) {
        return resolve({
          url: originalUrl,
          success: true,
          data: originalUrl,
          reason: "非TXT文件，无需解析",
        });
      }

      // 步骤3：TXT文件 → 用fetch下载并解析Base64（适配Vue3+Vite）
      // 超时任务：10秒超时（与原uni.request超时一致）
      const timeoutTask = new Promise((_, reject) => {
        setTimeout(() => reject(new Error("请求超时（超过10秒）")), 10000);
      });

      // 下载任务：请求代理后的TXT文件
      const fetchTask = fetch(proxyUrl, {
        method: "GET",
        headers: {
          "Content-Type": "text/plain", // 明确请求文本类型，避免解析异常
        },
      });

      // 竞速：超时/下载谁先完成取谁的结果
      Promise.race([fetchTask, timeoutTask])
        // 处理HTTP状态码（404/500等视为失败）
        .then((response) => {
          if (!response.ok) {
            throw new Error(
              `HTTP错误：${response.status} ${response.statusText}`
            );
          }
          return response.text(); // 读取TXT文本内容
        })
        // 解析Base64（关键：截取前235位）
        .then((rawBase64) => {
          const trimmedBase64 = (rawBase64 || "").toString().trim();

          // 校验：空Base64视为失败
          if (!trimmedBase64) {
            throw new Error(`TXT内容为空，无Base64数据`);
          }

          // 关键：截取前235位字符（与原逻辑一致）
          const pureBase64 = trimmedBase64.substring(235);
          if (!pureBase64) {
            throw new Error(
              `截取后无有效Base64（原始长度：${trimmedBase64.length}位）`
            );
          }

          // 生成完整Base64图片链接
          const fullBase64 = `data:image/${mimeType};base64,${pureBase64}`;
          resolve({
            url: originalUrl,
            success: true,
            data: fullBase64,
            reason: "TXT解析成功",
          });
        })
        // 捕获所有异常（超时/HTTP错误/解析错误/网络错误）
        .catch((err) => {
          const errReason = err.message || "未知错误";
          // 失败兜底：返回原始URL
          resolve({
            url: originalUrl,
            success: false,
            data: originalUrl,
            reason: errReason,
          });
        });
    });
  };

  // -------------------------- 批量处理所有URL --------------------------
  return new Promise((resolve) => {
    // 生成所有单个URL的处理任务
    const requestTasks = urls.map(handleSingleUrl);

    // 等待所有任务完成（成功/失败都处理）
    Promise.allSettled(requestTasks)
      .then((results) => {
        const list = results.map((result) => {
          // 任务成功：直接取结果
          if (result.status === "fulfilled") {
            return result.value;
          }
          // 任务被拒绝（极端异常）：兜底返回原始URL
          const failedUrl = result.reason?.url || "未知URL";
          return {
            url: failedUrl,
            success: false,
            data: failedUrl,
            reason: "任务执行被拒绝（极端异常）",
          };
        });

        const end = Date.now();
        const duration = end - start;
        resolve({ list, start, end, duration });
      })
      // 极端异常：Promise.allSettled本身失败（兜底所有URL为失败）
      .catch((allErr) => {
        const errReason = `批量处理崩溃：${allErr.message || "未知异常"}`;
        const list = urls.map((url) => ({
          url,
          success: false,
          data: url,
          reason: errReason,
        }));

        const end = Date.now();
        resolve({ list, start, end, duration: end - start });
      });
  });
}
